/** * @brief: Compute all the permutations of the given string that has all * unique characters. * @param: [in] str: The given string whose permutations will be computed. * @return: StringVect * A list of all the permutations of the given string. */ StringVect permutation_str_no_dup(const std::string & str) { const int STR_SIZE = static_cast<int>(str.size()); // Handle special cases. if (STR_SIZE == 0) { // If str is empty, return an empty set. return StringVect(); } else if (STR_SIZE == 1) { // One-char string has only one permutation which is itself. return StringVect(1, str); } // Now the STR_SIZE > 1. // Compute the permutations. char ch = str[0]; StringVect sub_perms = permutation_str_no_dup(str.substr(1)); // Insert ch to every possible position of perms. StringVect perms; for (size_t i = 0; i < sub_perms.size(); ++i) { const std::string & subperm = sub_perms[i]; for (size_t j = 0; j < subperm.size(); ++j) { std::string replica(subperm); replica.insert(replica.begin() + j, ch); perms.push_back(replica); } // Finally, we need to insert ch to the end of replica. std::string replica(subperm); replica.push_back(ch); perms.push_back(replica); } return perms; }
sql_rel * rel_distribute(mvc *sql, sql_rel *rel) { rel = distribute(sql, rel); rel = replica(sql, rel, NULL); return rel_remote_func(sql, rel); }
void ReplicaManagerWrapper::GenerateActiveReplicas( std::wstring const & replicasDescription, __out size_t & replicaCount, __out std::vector<ReplicaInformation> & replicaInfos) { vector<wstring> replicas; StringUtility::Split<wstring>(replicasDescription, replicas, L";"); replicaCount = replicas.size(); for(size_t i = 0; i < replicaCount; ++i) { vector<wstring> replicaDetails; AddIncarnationIdIfNecessary(replicas[i]); StringUtility::Split<wstring>(replicas[i], replicaDetails, L":"); ReplicationEndpointId endpointUniqueId = ReplicationEndpointId::FromString(replicaDetails[0]); int64 lsn = Int64_Parse(replicaDetails[1]); wstring endpoint; transport_->GeneratePublishEndpoint(endpointUniqueId, endpoint); ReplicaInformation replica( endpointUniqueId.ReplicaId, ::FABRIC_REPLICA_ROLE_ACTIVE_SECONDARY, endpoint, false, lsn, lsn); replicaInfos.push_back(std::move(replica)); } }
/*use to make a database * program [absolute name of logical file] [list of replicas] */ int main(int argc,char **argv){ saga::url plf(argv[1]); plf.set_host("localhost"); plf.set_scheme("any"); saga::logical_file::logical_file lf(plf, saga::logical_file::Create | saga::logical_file::CreateParents | saga::logical_file::ReadWrite); for(int x=2;x<argc;x++){ saga::url replica(argv[x]); replica.set_host("localhost"); replica.set_scheme("any"); lf.add_location(replica); } return 0; }
void ReplicaManagerWrapper::AddIdles(wstring const & idleReplicas) { Trace.WriteInfo(TestReplicaManagerSource, "** AddIdles {0}", idleReplicas); ReplicaInformationVector idles; vector<wstring> replicas; StringUtility::Split<wstring>(idleReplicas, replicas, L";"); size_t replicaCount = replicas.size(); FABRIC_SEQUENCE_NUMBER replLSN; for(size_t i = 0; i < replicaCount; ++i) { vector<wstring> replicaDetails; AddIncarnationIdIfNecessary(replicas[i]); StringUtility::Split<wstring>(replicas[i], replicaDetails, L":"); ReplicationEndpointId endpointUniqueId = ReplicationEndpointId::FromString(replicaDetails[0]); wstring endpoint; transport_->GeneratePublishEndpoint(endpointUniqueId, endpoint); ReplicaInformation replica( endpointUniqueId.ReplicaId, ::FABRIC_REPLICA_ROLE_IDLE_SECONDARY, endpoint, false, -1, -1); ReplicationSessionSPtr session; ErrorCode error = replicaManagerSPtr_->TryAddIdleReplica(replica, session, replLSN); VERIFY_IS_TRUE_FMT(error.IsSuccess(), "Added idle \"{0}\"", endpointUniqueId); int64 lsn = Int64_Parse(replicaDetails[1]); session->UpdateAckProgress(lsn, lsn, L"empty", nullptr); for (int count = 1; count < 100; count++) { if (session->Test_IsReplicationAckProcessingInProgress()) { Sleep(100); } else { break; } } } }
static sql_rel * distribute(mvc *sql, sql_rel *rel) { sql_rel *l = NULL, *r = NULL; prop *p, *pl, *pr; if (!rel) return rel; if (rel_is_ref(rel)) { if (has_remote_or_replica(rel)) { sql_rel *nrel = rel_copy(sql->sa, rel); if (nrel && rel->p) nrel->p = prop_copy(sql->sa, rel->p); rel_destroy(rel); rel = nrel; } else { return rel; } } switch (rel->op) { case op_basetable: { sql_table *t = rel->l; /* set_remote() */ if (isRemote(t)) { char *uri = t->query; p = rel->p = prop_create(sql->sa, PROP_REMOTE, rel->p); p->value = uri; } } case op_table: break; case op_join: case op_left: case op_right: case op_full: case op_apply: case op_semi: case op_anti: case op_union: case op_inter: case op_except: l = rel->l = distribute(sql, rel->l); r = rel->r = distribute(sql, rel->r); if (l && (pl = find_prop(l->p, PROP_REMOTE)) != NULL && r && (pr = find_prop(r->p, PROP_REMOTE)) == NULL) { r = rel->r = distribute(sql, replica(sql, rel->r, pl->value)); } else if (l && (pl = find_prop(l->p, PROP_REMOTE)) == NULL && r && (pr = find_prop(r->p, PROP_REMOTE)) != NULL) { l = rel->l = distribute(sql, replica(sql, rel->l, pr->value)); } if (l && (pl = find_prop(l->p, PROP_REMOTE)) != NULL && r && (pr = find_prop(r->p, PROP_REMOTE)) != NULL && strcmp(pl->value, pr->value) == 0) { l->p = prop_remove(l->p, pl); r->p = prop_remove(r->p, pr); pl->p = rel->p; rel->p = pl; } break; case op_project: case op_select: case op_groupby: case op_topn: case op_sample: rel->l = distribute(sql, rel->l); l = rel->l; if (l && (p = find_prop(l->p, PROP_REMOTE)) != NULL) { l->p = prop_remove(l->p, p); p->p = rel->p; rel->p = p; } break; case op_ddl: rel->l = distribute(sql, rel->l); if (rel->r) rel->r = distribute(sql, rel->r); break; case op_insert: case op_update: case op_delete: rel->r = distribute(sql, rel->r); break; } return rel; }
static sql_rel * replica(mvc *sql, sql_rel *rel, char *uri) { if (!rel) return rel; if (rel_is_ref(rel)) { if (has_remote_or_replica(rel)) { sql_rel *nrel = rel_copy(sql->sa, rel); if (nrel && rel->p) nrel->p = prop_copy(sql->sa, rel->p); rel_destroy(rel); rel = nrel; } else { return rel; } } switch (rel->op) { case op_basetable: { sql_table *t = rel->l; if (isReplicaTable(t)) { node *n; if (uri) { /* replace by the replica which matches the uri */ for (n = t->tables.set->h; n; n = n->next) { sql_table *p = n->data; if (isRemote(p) && strcmp(uri, p->query) == 0) { rel = rewrite_replica(sql, rel, t, p); break; } } } else { /* no match, use first */ sql_table *p = NULL; if (t->tables.set) { p = t->tables.set->h->data; rel = rewrite_replica(sql, rel, t, p); } else { rel = NULL; } } } } case op_table: break; case op_join: case op_left: case op_right: case op_full: case op_apply: case op_semi: case op_anti: case op_union: case op_inter: case op_except: rel->l = replica(sql, rel->l, uri); rel->r = replica(sql, rel->r, uri); break; case op_project: case op_select: case op_groupby: case op_topn: case op_sample: rel->l = replica(sql, rel->l, uri); break; case op_ddl: rel->l = replica(sql, rel->l, uri); if (rel->r) rel->r = replica(sql, rel->r, uri); break; case op_insert: case op_update: case op_delete: rel->r = replica(sql, rel->r, uri); break; } return rel; }
Try<Nothing> Initialize::execute(int argc, char** argv) { flags.setUsageMessage( "Usage: " + name() + " [option]\n" "\n" "This command is used to initialize the log.\n" "\n"); // Configure the tool by parsing command line arguments. if (argc > 0 && argv != NULL) { Try<Nothing> load = flags.load(None(), argc, argv); if (load.isError()) { return Error(flags.usage(load.error())); } if (flags.help) { return Error(flags.usage()); } process::initialize(); logging::initialize(argv[0], flags); } if (flags.path.isNone()) { return Error(flags.usage("Missing required option --path")); } // Setup the timeout if specified. Option<Timeout> timeout = None(); if (flags.timeout.isSome()) { timeout = Timeout::in(flags.timeout.get()); } Replica replica(flags.path.get()); // Get the current status of the replica. Future<Metadata::Status> status = replica.status(); if (timeout.isSome()) { status.await(timeout.get().remaining()); } else { status.await(); } if (status.isPending()) { return Error("Timed out while getting replica status"); } else if (status.isDiscarded()) { return Error("Failed to get status of replica (discarded future)"); } else if (status.isFailed()) { return Error(status.failure()); } // We only initialize a log if it is empty. if (status.get() != Metadata::EMPTY) { return Error("The log is not empty"); } // Update the status of the replica to VOTING. Future<bool> update = replica.update(Metadata::VOTING); if (timeout.isSome()) { update.await(timeout.get().remaining()); } else { update.await(); } if (update.isPending()) { return Error("Timed out while setting replica status"); } else if (update.isDiscarded()) { return Error("Failed to set replica status (discarded future)"); } else if (update.isFailed()) { return Error(update.failure()); } return Nothing(); }