anchor.diff:          ?assertEqual(ok, dirty_write(fakelog_1@, LogRec3#ddLog{logTime=erlang:now()})),
           ?assertEqual(2,length(physical_table_names(fakelog_1@))),
           timer:sleep(1100),
  -        ?assertEqual(ok, create_partitioned_table_sync(physical_table_name(fakelog_1@))),
  +        ?assertEqual(ok, create_partitioned_table_sync(fakelog_1@,physical_table_name(fakelog_1@))),
           ?assertEqual(3,length(physical_table_names(fakelog_1@))),
           ?Info("success ~p~n", [create_partitioned_table]),
   
  
positive.code: column_names(Infos)->
      [list_to_atom(lists:flatten(io_lib:format("~p", [N]))) || #ddColumn{name=N} <- Infos].
  
  column_infos(Table) when is_atom(Table) ->
      column_infos({schema(),Table});    
  column_infos({Schema,Table}) when is_binary(Schema), is_binary(Table) ->
      S= try 
          ?binary_to_existing_atom(Schema)
      catch 
          _:_ -> ?ClientError({"Schema does not exist",Schema})
      end,
      T = try 
          ?binary_to_existing_atom(Table)
      catch 
          _:_ -> ?ClientError({"Table does not exist",Table})
      end,        
      column_infos({S,T});
  column_infos({Schema,Table}) when is_atom(Schema), is_atom(Table) ->
      case lists:member(Table, ?DataTypes) of
          true -> 
              [#ddColumn{name=item, type=Table, len=0, prec=0, default=undefined}];
          false ->
              case imem_if:read(ddTable,{Schema, physical_table_name(Table)}) of
                  [] ->                       ?ClientError({"Table does not exist",{Schema,Table}}); 
                  [#ddTable{columns=CI}] ->   CI
              end
      end;  
  
negative.code:                 {Mega,Sec,_} = Key,
                  PartitionEnd=integer_to_list(Period*((1000000*Mega+Sec) div Period) + Period),
                  Prefix = lists:duplicate(10-length(PartitionEnd),$0),
                  {BaseName,_} = lists:split(length(TableAlias)-length(RN)-1, TableAlias),
                  lists:flatten(BaseName ++ Prefix ++ PartitionEnd ++ "@" ++ node_shard())
              catch
                  _:_ -> lists:flatten(TableAlias ++ node_shard())
              end;
           _ ->
              % node sharded table only   
              lists:flatten(TableAlias ++ node_shard())
      end.
  
  qualified_table_name({undefined,Table}) when is_atom(Table) ->              {schema(),Table};
  