anchor.diff:                  end;
               [] ->
                   % Table does not exist in ddTable, must create it similar to existing
  -                create_nonexisting_partitioned_table(Name)   
  +                create_nonexisting_partitioned_table(TableName)   
           end
       catch
           _:Reason1 ->
  
positive.code:             purge_time_partitioned_table(Alias, Opts)
      end.
  
  purge_time_partitioned_table(Alias, Opts) ->
      case lists:sort(simple_or_local_node_sharded_tables(Alias)) of
          [] ->
              ?ClientError({"Table to be purged does not exist",Alias});
          [PhName|Rest] ->
              KeepTime = case proplists:get_value(purge_delay, Opts) of
                  undefined ->    erlang:now();
                  Seconds ->      {Mega,Secs,Micro} = erlang:now(),
                                  {Mega,Secs-Seconds,Micro}
              end,
              KeepName = partitioned_table_name(Alias,KeepTime),
              if  
                  PhName >= KeepName ->
                      0; %% no memory could be freed       
                  true ->
                      ?Debug("Purge PhName KeepName ~p ~p~n",[PhName,KeepName]),
                      case Rest of
                          [] ->   DummyName = partitioned_table_name(Alias,erlang:now()),
                                  % ?Debug("Purge DummyName ~p~n",[DummyName]),
                                  create_partitioned_table(DummyName);
                          _ ->    ok
                      end,
                      FreedMemory = table_memory(PhName),
  
negative.code: physical_table_names(dba_tables) -> [ddTable];
  physical_table_names(all_tables) -> [ddTable];
  physical_table_names(user_tables) -> [ddTable];
  physical_table_names(TableAlias) when is_atom(TableAlias) ->
      case lists:member(TableAlias,?DataTypes) of
          true ->     [TableAlias];
          false ->    physical_table_names(atom_to_list(TableAlias))
      end;
  physical_table_names(TableAlias) when is_list(TableAlias) ->
      case lists:last(TableAlias) of
          $@ ->   
              case string:tokens(lists:reverse(TableAlias), "_") of
                  [[$@|RN]|_] ->
                      % timestamp sharded node sharded tables 
                      try 
                          _ = list_to_integer(lists:reverse(RN)),
                          {BaseName,_} = lists:split(length(TableAlias)-length(RN)-1, TableAlias),
                          Pred = fun(TN) -> lists:member($@, atom_to_list(TN)) end,
                          lists:filter(Pred,tables_starting_with(BaseName))
                      catch
                          _:_ -> tables_starting_with(TableAlias)
                      end;
                   _ ->   
                      % node sharded tables only   
                      tables_starting_with(TableAlias)
              end;
          _ ->    
              [list_to_atom(TableAlias)]
      end.
  
  partitioned_table_name(TableAlias,Key) ->
      list_to_atom(partitioned_table_name_str(TableAlias,Key)).
  
  partitioned_table_name_str(TableAlias,Key) when is_atom(TableAlias) ->
      partitioned_table_name_str(atom_to_list(TableAlias),Key);
  partitioned_table_name_str(TableAlias,Key) when is_list(TableAlias) ->
      case string:tokens(lists:reverse(TableAlias), "_") of
          [[$@|RN]|_] ->
              % timestamp sharded node sharded table 
              try 
  