anchor.diff:                                                          Trigger(Row2,{},PTN,User),
                                                           Row2
                                           end;
  -                    {remove,_,[R]} ->   delete(Table, Key),
  -                                        Trigger(R,{},Table,User),
  +                    {remove,_,[R]} ->   delete(TableAlias, Key),
  +                                        Trigger(R,{},TableAlias,User),
                                           R
                   end
               end,
               return_atomic(transaction(Trans));
           true ->     
  -            ?ClientError({"Not null constraint violation", {Table,Row2}})
  -    end.
  -
  -
  -delete({_Schema,Table}, Key) ->
  -    delete(Table, Key);             %% ToDo: may depend on schema
  -delete(Table, Key) ->
  -    imem_if:delete(physical_table_name(Table,Key), Key).
  -
  -delete_object({_Schema,Table}, Row) ->
  -    delete_object(Table, Row);             %% ToDo: may depend on schema
  -delete_object(Table, Row) ->
  -    imem_if:delete_object(physical_table_name(Table,element(?KeyIdx,Row)), Row).
  +            ?ClientError({"Not null constraint violation", {TableAlias,Row2}})
  +    end.
  +
  +
  +delete({_Schema,TableAlias}, Key) ->
  +    delete(TableAlias, Key);             %% ToDo: may depend on schema
  +delete(TableAlias, Key) ->
  +    imem_if:delete(physical_table_name(TableAlias,Key), Key).
  +
  +delete_object({_Schema,TableAlias}, Row) ->
  +    delete_object(TableAlias, Row);             %% ToDo: may depend on schema
  +delete_object(TableAlias, Row) ->
  +    imem_if:delete_object(physical_table_name(TableAlias,element(?KeyIdx,Row)), Row).
   
   subscribe({table, Tab, Mode}) ->
       PTN = physical_table_name(Tab),
  
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:                 end;
              [] ->
                  % Table does not exist in ddTable, must create it similar to existing
                  create_nonexisting_partitioned_table(TableName)   
          end
      catch
          _:Reason1 ->
  