renamenx work

Author: santosh79

lib/datastructures/list.ex

@@ -1,3 +1,5 @@
+alias Remixdb.ETSHelpers, as: ETSHelpers
+
 defmodule Remixdb.List do
   use GenServer
 
@@ -297,6 +299,18 @@ defmodule Remixdb.List do
     GenServer.call(@name, {:rename, old_name, new_name})
   end
 
+  def del(list_names) do
+    GenServer.call(@name, {:del, list_names})
+  end
+
+  def exists?(key) do
+    GenServer.call(@name, {:exists, key})
+  end
+
+  def renamenx(old_name, new_name) do
+    GenServer.call(@name, {:renamenx, old_name, new_name})
+  end
+
 
   # Example implementation adjustments for ETS
 
@@ -312,12 +326,10 @@ defmodule Remixdb.List do
   end
 
   def handle_call({:llen, list_name}, _from, table) do
-    size =
-      :ets.lookup(table, list_name)
-      |> case do
-           [] -> 0
-           [{_, list}] -> length(list)
-         end
+    size = case :ets.lookup(table, list_name) do
+             [] -> 0
+             [{_, list}] -> length(list)
+           end
 
     {:reply, size, table}
   end
@@ -405,20 +417,6 @@ defmodule Remixdb.List do
     {:noreply, table}
   end
 
-  def handle_call({:rename, old_name, new_name}, _from, table) do
-    case :ets.lookup(table, old_name) do
-      [] ->
-        # Old list does not exist
-        {:reply, false, table}
-
-      [{^old_name, list}] ->
-        # Insert under the new name and delete the old one
-        true = :ets.insert(table, {new_name, list})
-        true = :ets.delete(table, old_name)
-        {:reply, true, table}
-    end
-  end
-
   def handle_call({:rpop, list_name}, _from, table) do
     case :ets.lookup(table, list_name) do
       [] ->
@@ -504,6 +502,25 @@ defmodule Remixdb.List do
     end
   end
 
+  def handle_call({:renamenx, old_name, new_name}, _from, table) do
+    {:reply, ETSHelpers.renamenx(table, old_name, new_name), table}
+  end
+
+  def handle_call({:rename, old_name, new_name}, _from, table) do
+    {:reply, ETSHelpers.rename(table, old_name, new_name), table}
+  end
+
+  def handle_call({:exists, key}, _from, table) do
+    {:reply, ETSHelpers.exists?(table, key), table}
+  end
+
+  # del
+  def handle_call({:del, keys}, _from, table) do
+    :ok = ETSHelpers.del_keys(table, keys)
+    {:reply, "OK", table}
+  end
+
+
   # Implement other operations similarly, using ETS functions for state management
 
   # Helper function adjustments for ETS...
@@ -528,4 +545,5 @@ defmodule Remixdb.List do
       Enum.slice(list, norm_start, norm_stop - norm_start + 1)
     end
   end
+
 end

lib/datastructures/string.ex

@@ -1,4 +1,5 @@
 alias Remixdb.Counter, as: Counter
+alias Remixdb.ETSHelpers, as: ETSHelpers
 
 defmodule Remixdb.String do
   @moduledoc """
@@ -301,6 +302,11 @@ defmodule Remixdb.String do
     GenServer.call(@name, {:incrby, key, val * -1})
   end
 
+  def del(list_names) do
+    GenServer.call(@name, {:del, list_names})
+  end
+
+
   def handle_call(:flushall, _from, table) do
     :ets.delete(table)
     new_table = :ets.new(@name, [:named_table, :set, :public])
@@ -313,7 +319,7 @@ defmodule Remixdb.String do
   end
 
   def handle_call({:append, key, val}, _from, table) do
-    old_val = get_val(table, key)
+    old_val = ETSHelpers.get_val(table, key)
 
     new_val =
       case old_val do
@@ -327,82 +333,46 @@ defmodule Remixdb.String do
   end
 
   def handle_call({:incrby, key, incrby}, _from, table) do
-    new_val = Counter.incrby(get_val(table, key), incrby)
+    new_val = Counter.incrby(ETSHelpers.get_val(table, key), incrby)
     set_val(table, key, new_val)
     {:reply, new_val, table}
   end
 
   def handle_call({:get, key}, _from, table) do
-    val = get_val(table, key)
+    val = ETSHelpers.get_val(table, key)
     {:reply, val, table}
   end
 
   def handle_call({:getset, key, val}, _from, table) do
-    old_val = get_val(table, key)
+    old_val = ETSHelpers.get_val(table, key)
     set_val(table, key, val)
     {:reply, old_val, table}
   end
 
   def handle_call({:set, key, val}, _from, table) do
-    set_val(table, key, val)
+    :ok = set_val(table, key, val)
     {:reply, :ok, table}
   end
 
   def handle_call({:renamenx, old_name, new_name}, _from, table) do
-    case get_val(table, old_name) do
-      nil ->
-        response = {:error, "ERR no such key"}
-        {:reply, response, table}
-      _ ->
-        case get_val(table, new_name) do
-          nil ->
-            private_rename(old_name, new_name, table)
-            {:reply, "1", table}
-          _ -> 
-            {:reply, "0", table}
-        end
-    end
+    {:reply, ETSHelpers.renamenx(table, old_name, new_name), table}
   end
 
   def handle_call({:rename, old_name, new_name}, _from, table) do
-    result = private_rename(old_name, new_name, table)
-    {:reply, result, table}
+    {:reply, ETSHelpers.rename(table, old_name, new_name), table}
   end
 
   def handle_call({:exists, key}, _from, table) do
-    case get_val(table, key) do
-      nil -> false
-      _ -> true
-    end
-  end
-
-  defp private_rename(old_name, new_name, table) do
-    old_value =
-      case :ets.lookup(table, old_name) do
-        [{^old_name, value}] -> value
-        [] -> nil
-      end
-
-    case old_value do
-      nil ->
-        false
-
-      _ ->
-        true = :ets.insert(table, {new_name, old_value})
-        true = :ets.delete(table, old_name)
-        true
-    end
+    {:reply, ETSHelpers.exists?(table, key), table}
   end
-  
 
-  defp get_val(table, key) do
-    case :ets.lookup(table, key) do
-      [{^key, value}] -> value
-      [] -> nil
-    end
+  def handle_call({:del, keys}, _from, table) do
+    :ok = ETSHelpers.del_keys(table, keys)
+    {:reply, "OK", table}
   end
 
   defp set_val(table, key, val) do
-    :ets.insert(table, {key, val})
+    :ok = ETSHelpers.put_val(table, key, val)
+    :ok
   end
 end

lib/parsers/redis_parser.ex

@@ -129,6 +129,7 @@ defmodule Remixdb.Parsers.RedisParser do
       "HEXISTS" -> {:hexists, args}
       "HSTRLEN" -> {:hstrlen, args}
       "HINCRBY" -> {:hincrby, args}
+      "DEL" -> {:del, args}
     end
   end
 end