id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c177200 | criteria[i] = fmt.Sprintf("%s = ?", field.Column())
}
return strings.Join(criteria, " AND ")
} | |
c177201 | retrieve current cluster config")
}
// Check if already enabled
if !currentCluster.Enabled {
// Configure the cluster
op, err := d.UpdateCluster(config.ClusterPut, etag)
if err != nil {
return errors.Wrap(err, "Failed to configure cluster")
}
err = op.Wait()
if err != nil {
return errors.Wrap(err, "Failed to configure cluster")
}
}
return nil
} | |
c177202 | {
props[errorKey] = fmt.Sprintf("%+v is not a string key", r.Ctx[i])
}
props[k] = formatJsonValue(r.Ctx[i+1])
}
b, err := jsonMarshal(props)
if err != nil {
b, _ = jsonMarshal(map[string]string{
errorKey: err.Error(),
})
return b
}
if lineSeparated {
b = append(b, '\n')
}
return b
})
} | |
c177203 | int32, int64, uint, uint8, uint16, uint32, uint64:
return fmt.Sprintf("%d", value)
case string:
return escapeString(v)
default:
return escapeString(fmt.Sprintf("%+v", value))
}
} | |
c177204 | db.ErrNoSuchObject {
return fmt.Errorf("No cluster member called '%s'", target)
}
return err
}
if node.Name != name {
address = node.Address
}
return nil
})
return address, err
} | |
c177205 | if pt.Tracker != nil {
pt.Tracker.total += int64(n)
pt.Tracker.update(n)
}
return n, err
} | |
c177206 | n, err := result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return fmt.Errorf("updated %d rows instead of 1", n)
}
return nil
} | |
c177207 | {
return nil, err
}
defer stmt.Close()
err = query.SelectObjects(stmt, dest)
if err != nil {
return nil, err
}
return versions, nil
} | |
c177208 |
personalities, err := osarch.ArchitecturePersonalities(architecture)
if err != nil {
return nil, err
}
for _, personality := range personalities {
architectures = append(architectures, personality)
}
return architectures, nil
} | |
c177209 | num
case 1:
min = num
case 2:
mic = num
}
}
/* Major version is greater. */
if maj > major {
return true
}
if maj < major {
return false
}
/* Minor number is greater.*/
if min > minor {
return true
}
if min < minor {
return false
}
/* Patch number is greater. */
if mic > micro {
return true
}
if mic < micro {
return false
}
return true
} | |
c177210 | os.Readlink("/proc/self/exe")
if err != nil {
execPath = "bad-exec-path"
}
return execPath
} | |
c177211 | {
args.UserAgent = "lxd-cluster-notifier"
}
url := fmt.Sprintf("https://%s", address)
return lxd.ConnectLXD(url, args)
} | |
c177212 | {
var err error
address, err = tx.ContainerNodeAddress(project, name)
return err
})
if err != nil {
return nil, err
}
if address == "" {
// The container is running right on this node, no need to connect.
return nil, nil
}
return Connect(address, cert, false)
} | |
c177213 |
})
if err != nil {
return nil, err
}
if len(addresses) > 1 {
var driver string
err := cluster.Transaction(func(tx *db.ClusterTx) error {
var err error
driver, err = tx.StoragePoolDriver(poolID)
return err
})
if err != nil {
return nil, err
}
if driver == "ceph" {
return nil, nil
}
return nil, fmt.Errorf("more than one node has a volume named %s", volumeName)
}
address := addresses[0]
if address == "" {
return nil, nil
}
return Connect(address, cert, false)
} | |
c177214 | != nil {
return errors.Wrap(err, "failed to calculate fingerprint")
}
post.Name = fmt.Sprintf("lxd.cluster.%s", fingerprint)
post.Type = "client"
err = target.CreateCertificate(post)
if err != nil && err.Error() != "Certificate already in trust store" {
return errors.Wrap(err, "Failed to add client cert to cluster")
}
return nil
} | |
c177215 | _, err := r.queryStruct("GET", "/storage-pools?recursion=1", nil, "", &pools)
if err != nil {
return nil, err
}
return pools, nil
} | |
c177216 | etag, err := r.queryStruct("GET", fmt.Sprintf("/storage-pools/%s", url.QueryEscape(name)), nil, "", &pool)
if err != nil {
return nil, "", err
}
return &pool, etag, nil
} | |
c177217 | pool.Driver == "ceph" && !r.HasExtension("storage_driver_ceph") {
return fmt.Errorf("The server is missing the required \"storage_driver_ceph\" API extension")
}
// Send the request
_, _, err := r.query("POST", "/storage-pools", pool, "")
if err != nil {
return err
}
return nil
} | |
c177218 | _, err := r.query("PUT", fmt.Sprintf("/storage-pools/%s", url.QueryEscape(name)), pool, ETag)
if err != nil {
return err
}
return nil
} | |
c177219 | fmt.Sprintf("/storage-pools/%s", url.QueryEscape(name)), nil, "")
if err != nil {
return err
}
return nil
} | |
c177220 | _, err := r.queryStruct("GET", fmt.Sprintf("/storage-pools/%s/resources", url.QueryEscape(name)), nil, "", &res)
if err != nil {
return nil, err
}
return &res, nil
} | |
c177221 | {filepath.Join(s.VarDir, "disks"), 0700},
{filepath.Join(s.VarDir, "images"), 0700},
{s.LogDir, 0700},
{filepath.Join(s.VarDir, "networks"), 0711},
{filepath.Join(s.VarDir, "security"), 0700},
{filepath.Join(s.VarDir, "shmounts"), 0711},
{filepath.Join(s.VarDir, "snapshots"), 0700},
{filepath.Join(s.VarDir, "storage-pools"), 0711},
}
for _, dir := range dirs {
err := os.Mkdir(dir.path, dir.mode)
if err != nil && !os.IsExist(err) {
return errors.Wrapf(err, "failed to init dir %s", dir.path)
}
}
return nil
} | |
c177222 | query.SelectConfig(n.tx, "config", "")
} | |
c177223 | query.UpdateConfig(n.tx, "config", values)
} | |
c177224 | query.SelectConfig(c.tx, "config", "")
} | |
c177225 | query.UpdateConfig(c.tx, "config", values)
} | |
c177226 | := util.CopyConfig(dbConfig)
for _, key := range db.StoragePoolNodeConfigKeys {
delete(config, key)
}
return config
} | |
c177227 | for _, listener := range r.eventListeners {
listener.err = err
listener.disconnected = true
close(listener.chActive)
}
// And remove them all from the list
r.eventListeners = nil
conn.Close()
close(stopCh)
return
}
// Attempt to unpack the message
event := api.Event{}
err = json.Unmarshal(data, &event)
if err != nil {
continue
}
// Extract the message type
if event.Type == "" {
continue
}
// Send the message to all handlers
r.eventListenersLock.Lock()
for _, listener := range r.eventListeners {
listener.targetsLock.Lock()
for _, target := range listener.targets {
if target.types != nil && !shared.StringInSlice(event.Type, target.types) {
continue
}
go target.function(event)
}
listener.targetsLock.Unlock()
}
r.eventListenersLock.Unlock()
}
}()
return &listener, nil
} | |
c177228 | r.KeyNames.Msg, r.Msg}
buf := &bytes.Buffer{}
logfmt(buf, common, 0, false)
buf.Truncate(buf.Len() - 1)
buf.WriteByte(' ')
logfmt(buf, r.Ctx, 0, true)
return buf.Bytes()
})
} | |
c177229 |
defer stmt.Close()
err = query.SelectObjects(stmt, dest, poolID, project, name, typ)
if err != nil {
return nil, err
}
addresses := []string{}
for _, node := range nodes {
address := node.address
if node.id == c.nodeID {
address = ""
}
addresses = append(addresses, address)
}
sort.Strings(addresses)
if len(addresses) == 0 {
return nil, ErrNoSuchObject
}
return addresses, nil
} | |
c177230 | dbQueryRowScan(c.db, query, inargs, outargs)
if err != nil {
if err == sql.ErrNoRows {
return "", ErrNoSuchObject
}
return "", err
}
return name, nil
} | |
c177231 | nil {
return nil, err
}
config := map[string]string{}
for _, r := range results {
key = r[0].(string)
value = r[1].(string)
config[key] = value
}
return config, nil
} | |
c177232 | inargs := []interface{}{volumeID}
outargs := []interface{}{&description}
err := dbQueryRowScan(c.db, query, inargs, outargs)
if err != nil {
if err == sql.ErrNoRows {
return "", ErrNoSuchObject
}
return "", err
}
return description.String, nil
} | |
c177233 | {
continue
}
if device["pool"] != pool {
continue
}
if device["source"] != volume {
continue
}
if container.Node != node {
// This ceph volume is already attached
// to a container on a different node.
return nil
}
}
}
isAvailable = true
return nil
})
if err != nil {
return false, err
}
return isAvailable, nil
} | |
c177234 | description=? WHERE id=?", description, volumeID)
return err
} | |
c177235 | return err
}
for k, v := range volumeConfig {
if v == "" {
continue
}
_, err = stmt.Exec(volumeID, k, v)
if err != nil {
return err
}
}
return nil
} | |
c177236 | FROM storage_volumes_config WHERE storage_volume_id=?", volumeID)
if err != nil {
return err
}
return nil
} | |
c177237 | = storage_volumes.project_id
WHERE projects.name=? AND storage_volumes.name=? AND storage_volumes.type=? AND storage_pool_id=?
`, project, volumeName, volumeType, poolID)
if err != nil {
return nil, err
}
ids64 := make([]int64, len(ids))
for i, id := range ids {
ids64[i] = int64(id)
}
return ids64, nil
} | |
c177238 |
for _, fingerprint := range fingerprints {
args = append(args, fingerprint)
}
err := exec(c.db, stmt, args...)
return err
} | |
c177239 | exec(c.db, "DELETE FROM storage_volumes_config WHERE key='lvm.thinpool_name';")
if err != nil {
return err
}
return nil
} | |
c177240 | fmt.Fprintf(b.buf, format, a...)
b.N()
} | |
c177241 | nil, errors.Wrap(err, "Can't format generated source code")
}
return code, nil
} | |
c177242 | return fmt.Sprintf("%v", input)
}
return fmt.Sprintf("\n\t%s", pretty)
} | |
c177243 | defer e.mu.RUnlock()
return e.cert.PublicKey()
} | |
c177244 | defer e.mu.RUnlock()
return e.cert.PrivateKey()
} | |
c177245 | defer e.mu.RUnlock()
return e.cert
} | |
c177246 |
listener := e.listeners[network]
if listener == nil {
return ""
}
return listener.Addr().String()
} | |
c177247 | }
time.Sleep(100 * time.Millisecond)
}
if err != nil {
return nil, fmt.Errorf("cannot listen on https socket: %v", err)
}
return &listener, nil
}
// If setting a new address, setup the listener
if address != "" {
listener, err := getListener(address)
if err != nil {
// Attempt to revert to the previous address
listener, err1 := getListener(oldAddress)
if err1 == nil {
e.listeners[network] = networkTLSListener(*listener, e.cert)
e.serveHTTP(network)
}
return err
}
e.listeners[network] = networkTLSListener(*listener, e.cert)
e.serveHTTP(network)
}
return nil
} | |
c177248 | too, if enabled.
listener, ok = e.listeners[cluster]
if !ok {
return
}
listener.(*networkListener).Config(cert)
} | |
c177249 | listen on https socket, skipping...", log.Ctx{"err": err})
return nil
}
return networkTLSListener(listener, cert)
} | |
c177250 | err != nil {
return nil, err
}
l.mu.RLock()
defer l.mu.RUnlock()
config := l.config
return tls.Server(c, config), nil
} | |
c177251 | l.mu.Lock()
defer l.mu.Unlock()
l.config = config
} | |
c177252 | nodeIsOffline(threshold, n.Heartbeat)
} | |
c177253 |
case 0:
return null, ErrNoSuchObject
case 1:
return nodes[0], nil
default:
return null, fmt.Errorf("more than one node matches")
}
} | |
c177254 |
case 0:
return null, ErrNoSuchObject
case 1:
return nodes[0], nil
default:
return null, fmt.Errorf("more than one node matches")
}
} | |
c177255 |
case 0:
return null, ErrNoSuchObject
case 1:
return nodes[0], nil
default:
return null, fmt.Errorf("more than one node matches")
}
} | |
c177256 |
case 0:
return "", nil
case 1:
return names[0], nil
default:
return "", fmt.Errorf("inconsistency: non-unique node ID")
}
} | |
c177257 | {
case 0:
return "", nil
case 1:
return addresses[0], nil
default:
return "", fmt.Errorf("inconsistency: non-unique node ID")
}
} | |
c177258 | := range nodes {
if node.ID == c.nodeID {
continue
}
n, err := util.CompareVersions(node.Version(), version)
if err != nil {
errors.Wrapf(err, "Failed to compare with version of node %s", node.Name)
}
if n == 1 {
// The other node's version is greater than ours.
return true, nil
}
}
return false, nil
} | |
c177259 | return 0, errors.Wrap(err, "failed to count existing nodes")
}
return count, nil
} | |
c177260 | nodes SET name=? WHERE name=?`
result, err := c.tx.Exec(stmt, new, old)
if err != nil {
return errors.Wrap(err, "failed to update node name")
}
n, err := result.RowsAffected()
if err != nil {
return errors.Wrap(err, "failed to get rows count")
}
if n != 1 {
return fmt.Errorf("expected to update one row, not %d", n)
}
return nil
} | |
c177261 | schema, api_extensions, heartbeat FROM nodes WHERE pending=? `
if where != "" {
sql += fmt.Sprintf("AND %s ", where)
}
sql += "ORDER BY id"
stmt, err := c.tx.Prepare(sql)
if err != nil {
return nil, err
}
defer stmt.Close()
err = query.SelectObjects(stmt, dest, args...)
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch nodes")
}
return nodes, nil
} | |
c177262 | "api_extensions"}
values := []interface{}{name, address, cluster.SchemaVersion, version.APIExtensionsCount()}
return query.UpsertObject(c.tx, "nodes", columns, values)
} | |
c177263 | n, err := result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return fmt.Errorf("query updated %d rows instead of 1", n)
}
return nil
} | |
c177264 | err := result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return fmt.Errorf("query updated %d rows instead of 1", n)
}
return nil
} | |
c177265 | {
return err
}
if n != 1 {
return fmt.Errorf("query deleted %d rows instead of 1", n)
}
return nil
} | |
c177266 | result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return fmt.Errorf("expected to update one row and not %d", n)
}
return nil
} | |
c177267 | image.nodeID)
}
fingerprints := []string{}
for fingerprint, ids := range index {
if len(ids) > 1 {
continue
}
if ids[0] == id {
fingerprints = append(fingerprints, fingerprint)
}
}
if len(fingerprints) > 0 {
message := fmt.Sprintf(
"Node still has the following images: %s", strings.Join(fingerprints, ", "))
return message, nil
}
// Check if the node has any custom volumes.
volumes, err := query.SelectStrings(
c.tx, "SELECT name FROM storage_volumes WHERE node_id=? AND type=?",
id, StoragePoolVolumeTypeCustom)
if err != nil {
return "", errors.Wrapf(err, "Failed to get custom volumes for node %d", id)
}
if len(volumes) > 0 {
message := fmt.Sprintf(
"Node still has the following custom volumes: %s", strings.Join(volumes, ", "))
return message, nil
}
return "", nil
} | |
c177268 | image as well if this was the only node with it.
for _, id := range ids {
count, err := query.Count(c.tx, "images_nodes", "image_id=?", id)
if err != nil {
return err
}
if count > 0 {
continue
}
_, err = c.tx.Exec("DELETE FROM images WHERE id=?", id)
if err != nil {
return err
}
}
return nil
} | |
c177269 |
if len(values) > 0 {
seconds, err := strconv.Atoi(values[0])
if err != nil {
return -1, err
}
threshold = time.Duration(seconds) * time.Second
}
return threshold, nil
} | |
c177270 | if err != nil {
return errors.Wrap(err, "Failed to update nodes table")
}
n, err := result.RowsAffected()
if err != nil {
return errors.Wrap(err, "Failed to get affected rows")
}
if n != 1 {
return fmt.Errorf("Expected exactly one row to be updated")
}
return nil
} | |
c177271 | return rollback(tx, err)
}
err = tx.Commit()
if err == sql.ErrTxDone {
err = nil // Ignore duplicate commits/rollbacks
}
return err
} | |
c177272 | after error (%v): %v", reason, err)
}
return reason
} | |
c177273 | filter.Name,
}
} else if criteria["Project"] != nil {
stmt = c.stmt(profileNamesByProject)
args = []interface{}{
filter.Project,
}
} else {
stmt = c.stmt(profileNames)
args = []interface{}{}
}
code := cluster.EntityTypes["profile"]
formatter := cluster.EntityFormatURIs[code]
return query.SelectURIs(stmt, formatter, args...)
} | |
c177274 |
switch len(objects) {
case 0:
return nil, ErrNoSuchObject
case 1:
return &objects[0], nil
default:
return nil, fmt.Errorf("More than one profile matches")
}
} | |
c177275 | if err == ErrNoSuchObject {
return false, nil
}
return false, err
}
return true, nil
} | |
c177276 |
stmt = c.stmt(profileConfigRefByProject)
args = []interface{}{
filter.Project,
}
} else {
stmt = c.stmt(profileConfigRef)
args = []interface{}{}
}
// Dest function for scanning a row.
dest := func(i int) []interface{} {
objects = append(objects, struct {
Project string
Name string
Key string
Value string
}{})
return []interface{}{
&objects[i].Project,
&objects[i].Name,
&objects[i].Key,
&objects[i].Value,
}
}
// Select.
err := query.SelectObjects(stmt, dest, args...)
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch ref for profiles")
}
// Build index by primary name.
index := map[string]map[string]map[string]string{}
for _, object := range objects {
_, ok := index[object.Project]
if !ok {
subIndex := map[string]map[string]string{}
index[object.Project] = subIndex
}
item, ok := index[object.Project][object.Name]
if !ok {
item = map[string]string{}
}
index[object.Project][object.Name] = item
item[object.Key] = object.Value
}
return index, nil
} | |
c177277 | Name string
Value string
}{})
return []interface{}{
&objects[i].Project,
&objects[i].Name,
&objects[i].Value,
}
}
// Select.
err := query.SelectObjects(stmt, dest, args...)
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch string ref for profiles")
}
// Build index by primary name.
index := map[string]map[string][]string{}
for _, object := range objects {
_, ok := index[object.Project]
if !ok {
subIndex := map[string][]string{}
index[object.Project] = subIndex
}
item, ok := index[object.Project][object.Name]
if !ok {
item = []string{}
}
index[object.Project][object.Name] = append(item, object.Value)
}
return index, nil
} | |
c177278 | typ, ok := config["type"]
if !ok {
return -1, fmt.Errorf("No type for device %s", name)
}
typCode, err := dbDeviceTypeToInt(typ)
if err != nil {
return -1, errors.Wrapf(err, "Device type code for %s", typ)
}
stmt = c.stmt(profileCreateDevicesRef)
result, err := stmt.Exec(id, name, typCode)
if err != nil {
return -1, errors.Wrapf(err, "Insert device %s", name)
}
deviceID, err := result.LastInsertId()
if err != nil {
return -1, errors.Wrap(err, "Failed to fetch device ID")
}
stmt = c.stmt(profileCreateDevicesConfigRef)
for key, value := range config {
_, err := stmt.Exec(deviceID, key, value)
if err != nil {
return -1, errors.Wrap(err, "Insert config for profile")
}
}
}
return id, nil
} | |
c177279 | err != nil {
return errors.Wrap(err, "Fetch affected rows")
}
if n != 1 {
return fmt.Errorf("Query affected %d rows instead of 1", n)
}
return nil
} | |
c177280 | {
return errors.Wrap(err, "Fetch affected rows")
}
if n != 1 {
return fmt.Errorf("Query deleted %d rows instead of 1", n)
}
return nil
} | |
c177281 |
pool.AddCert(cert.CA())
config.RootCAs = pool
config.ClientCAs = pool
logger.Infof("LXD is in CA mode, only CA-signed certificates will be allowed")
}
config.BuildNameToCertificate()
return config
} | |
c177282 | continue
}
addr, ok := addrs[0].(*net.IPNet)
if !ok {
continue
}
return addr.IP.String()
}
return ""
} | |
c177283 | // only covered if it's an IPv4 address.
if host2 == "0.0.0.0" {
ip := net.ParseIP(host1)
if ip != nil && ip.To4() != nil {
return true
}
return false
}
// If address2 is using an IPv6 wildcard for the host, then address2 is
// always covered.
if host2 == "::" || host2 == "" {
return true
}
return false
} | |
c177284 | := rows.Scan(dest(i)...)
if err != nil {
return err
}
}
err = rows.Err()
if err != nil {
return err
}
return nil
} | |
c177285 | result.RowsAffected()
if err != nil {
return false, err
}
if n > 1 {
return true, fmt.Errorf("more than one row was deleted")
}
return n == 1, nil
} | |
c177286 | // never expire (hence the task function won't ever be
// run, unless Reset() is called and schedule() starts
// returning values greater than zero).
if schedule > 0 {
timer = time.After(delay)
} else {
timer = make(chan time.Time)
}
default:
// If the schedule is not greater than zero, abort the
// task and return immediately. Otherwise set up the
// timer to retry after that amount of time.
if schedule <= 0 {
return
}
timer = time.After(schedule)
}
select {
case <-timer:
if err == nil {
// Execute the task function synchronously. Consumers
// are responsible for implementing proper cancellation
// of the task function itself using the tomb's context.
t.f(ctx)
delay = schedule
} else {
// Don't execute the task function, and set the
// delay to run it immediately whenever the
// schedule function returns a nil error.
delay = immediately
}
case <-ctx.Done():
return
case <-t.reset:
delay = immediately
}
}
} | |
c177287 | GetState(fd)
return err == nil
} | |
c177288 |
listener, err := net.ListenUnix("unix", addr)
if err != nil {
return nil, fmt.Errorf("cannot bind socket: %v", err)
}
return listener, err
} | |
c177289 |
if err != nil {
return fmt.Errorf("could not delete stale local socket: %v", err)
}
return nil
} | |
c177290 | return fmt.Errorf("cannot set permissions on local socket: %v", err)
}
return nil
} | |
c177291 | gid = os.Getgid()
}
err = os.Chown(path, os.Getuid(), gid)
if err != nil {
return fmt.Errorf("cannot change ownership on local socket: %v", err)
}
return nil
} | |
c177292 |
"osd",
"pool",
"get",
poolName,
"size")
if err != nil {
return false
}
return true
} | |
c177293 | userName),
"--cluster", clusterName,
"osd",
"pool",
"delete",
poolName,
poolName,
"--yes-i-really-really-mean-it")
if err != nil {
return err
}
return nil
} | |
c177294 |
"list",
fmt.Sprintf("%s_%s", volumeType, volumeName))
if err != nil {
return false
}
return true
} | |
c177295 | if ok {
waitStatus := exitError.Sys().(syscall.WaitStatus)
if waitStatus.ExitStatus() == 16 {
// EBUSY (snapshot already protected)
return nil
}
}
}
return err
}
return nil
} | |
c177296 | "--image-feature", "layering",
"clone",
fmt.Sprintf("%s/%s_%s@%s", sourcePoolName, sourceVolumeType,
sourceVolumeName, sourceSnapshotName),
fmt.Sprintf("%s/%s_%s", targetPoolName, targetVolumeType,
targetVolumeName))
if err != nil {
return err
}
return nil
} | |
c177297 | "--snap", snapshotName)
if err != nil {
return nil, err
}
msg = strings.TrimSpace(msg)
clones := strings.Fields(msg)
if len(clones) == 0 {
return nil, db.ErrNoSuchObject
}
return clones, nil
} | |
c177298 | }
_, err := shared.RunCommand(
"rbd",
"--id", userName,
"--cluster", clusterName,
"mv",
fmt.Sprintf("%s/%s_%s", poolName, volumeType, oldVolumeName),
deletedName)
if err != nil {
return err
}
return nil
} | |
c177299 | volumeType, volumeName)
if newSuffix != "" {
newName = fmt.Sprintf("%s_%s", newName, newSuffix)
}
_, err := shared.RunCommand(
"rbd",
"--id", userName,
"--cluster", clusterName,
"mv",
oldName,
newName)
if err != nil {
return err
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.