Auron

[Python] On Computing permutations with a recursive generator expression

2008-10-22T08:20:01-07:00

Your code works great but addresses a different problem than this one (http://refactormycode.com/codes/523-permutation-of-values), which is really not a permutation (it was my fault).

I like your one-line solution, although I find it difficult to understand :)

[Python] On Permutation of values

2008-10-08T16:55:10-07:00

My second proposal is based in an idea from a peer at work, so credits for him, please. I've just adapted it to Python. I think it uses a very intelligent point of view, and resolves the problem elegantly and without recursion, which is great.

def cart(maxs):
    """
    Compute each new result as it if was a number where digit i is of
    base maxs[i]. As it happens with natural numbers, we add one to the
    least significant digit in order to obtain the next number. If the
    digit is above a limit, it turns out zero, and we instead add one to
    the next significant digit, and so on and so for:
    
    ... 1 8    --->    1 9    --->    2 0 (In base 10, we reset 9 to 0
               (+1)           (+1)        and add one to the next digit)
    
    The results of this fuction are very similar, but each digit is of
    a different base. 
    """
    # The first result will be a list of zeroes, that's for sure.
    result = [0 for i in xrange(len(maxs))]
    
    yield result[:]         # You can't yield the result as it is, because the
                            # result reference will be used along the function.
                            # Hence, we return a copy.
    
    # Get the number of different results we will obtain.
    numResults = reduce(lambda x,y: x * y, maxs)
    
    # Now, get each result.
    for n in xrange(1, numResults):
        for i in xrange(len(maxs) - 1, -1, -1):
            if i == len(maxs) - 1:
                result[i] = result[i] + 1
                
            elif result[i + 1] >= maxs[i + 1]:
                result[i + 1] = 0
                result[i] = result[i] + 1
                
            else:
                break
        
        yield result[:]
        
if __name__ == "__main__":
    l = [3, 4]
    print list(cart(l))

[Python] On Permutation of values

2008-10-07T14:44:17-07:00

Excellent! I have to recognize that using both recursion and the yield statement is a bit tricky to me, and I'm having a bad time trying to fully understand your code. I've changed the variable names in order to clarify it a bit, but is not trivial at all :)

def cart(posValuesHead, *posValuesTail):
    if not posValuesTail:
        for posValue in posValuesHead:
            yield [posValue]
    else:
        for posValue in posValuesHead:
            for subresult in cart(posValuesTail[0], *posValuesTail[1:]):
                yield [posValue] + subresult

def perm(maxList):
    posValues = []                    # posValues stands for possible values.
    
    for max in maxList:
        posValues.append(xrange(max))
        
    return cart(*posValues)

if __name__ == "__main__":
    l = [2, 3]
    print list(perm(l))

[Python] Permutation of values

2008-10-07T12:18:49-07:00

Boys and girls, it's time to PYTHON!!! The following piece of code computes, given a list of numbers where each value represent the upper limit an element of a list of the same size can reach, all lists that is possible to build.

Sorry, my English is a bit crappy, but the problem is not as difficult to understand as it may seem. Let's say I have the following list of size 2:

[2, 3]

I want all the possible lists of size 2 (the same length of the original list) where the first element can be 0 or 1 and the second and last element can be 0, 1 or 2. The result should be:

[[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2]]

That's what the following function does. It is actually based on recursion, but I think it can be do better. What do you think?

def perm(ni):
    result = []
    
    # Base case: The list length is zero. The only possible permutation is as well 
    # an empty array.
    if len(ni) == 0:
        result.append([])
        return result 

    # Get all possible permutations for the tail of the list.
    subresult = perm(ni[1:])
    
    # Get each possible value for the head and concat with each permutation
    # previously computed.
    for i in range(ni[0]):    
        for array in subresult:
            result.append([i] + array)

    return result

if __name__ == "__main__":
    l = [2, 3, 4]
    print perm(l)

[C#] On TableAdapter and CommandTimeout

2008-09-22T12:21:09-07:00

I think our solutions did take into account stored procedures (in the TableAdapter's CommandCollection). Nevertheless, your approach seems also correct to me (although without the beauty of generics :P).

[C#] On TableAdapter and CommandTimeout

2008-07-03T13:59:19-07:00

You see, I don't find using generics as bad. Between your code and mine, I think I (and anyone) can reach to a consensus according to our needs. Thank you very much :).

[C#] On TableAdapter and CommandTimeout

2008-07-03T10:19:10-07:00

Oh, yes, you're right. I didn't see the whole point of your code and I realize I finally made a mess. My apologies but...

As you put it, you have to implement Accessor as a public static class and use it every time you want to set the command timeout and then fill the associated table. At the same time, you could create TableAdapters on your own, but you couldn't modify the command timeout.

So, it's like if you have two flavours of TableAdapters for each MyTableAdapter implemented in your code:

* A kind of "singleton" instance MyTableAdapter stored in the Accessor<MyTableAdapter> class: you can access this TableAdapter's SQLCommands through the accessor.
* Every time you make new MyTableAdapter in your code aouside the Accessor(with the 'new' keyword), you'll have a new "instance" of MyTableAdapter. You can't access to its SQLCommands.

That's a big downside in my opinion. It would be great if all TableAdapters could be automatically extended, but "there is no silver bullet", I suppose :)

Another downside is that you give access to all the internal commands of the singleton TableAdapter, and I think this commands shouldn't be reachable at all. My following code solves this issue.

> You've added a lot of explicit namespaces. Maybe you have copied it from the dataset generated classes? You don't need it, and they uglify the code a lot.

Yes, I know. I did it because it makes the code more fail-proof, if someone copy that code in his codebase, it will work, no matter what namespaces he had created :)

> But most of all, you have copied and pasted the reflecting accessor method for both the properties.
> That's BAD, I'm sorry.
> Did you recognize that the GetDataAdapter and GetCommandCollection are the same method, except for the name of the property and the type you cast it. Use the parameters!

Yes, you're right. I've already solved that (see code below).

> I'm sorry, but I will give you a 1 star to your refactoring, but I'll wait until you tell me what I can't understand.

I'm OK with that. In fact, I don't know if I should delete it or not.

Thanks.

## This is the code.

using System.Data;
using System.Data.SqlClient;
using System.Reflection;

namespace MyDataSetTableAdapters {

    internal static class TableAdapterAccessor<TableAdapter> where TableAdapter : new() {

        private static TableAdapter instance = new TableAdapter();

        public static TableAdapter Adapter { get { return instance; } }

        public static int InsertCommandTimeout {
            get { return InsertCommand.CommandTimeout;  }
            set { InsertCommand.CommandTimeout = value; }
        }

        public static int UpdateCommandTimeout {
            get { return UpdateCommand.CommandTimeout; }
            set { UpdateCommand.CommandTimeout = value; }
        }

        public static int DeleteCommandTimeout {
            get { return DeleteCommand.CommandTimeout;  }
            set { DeleteCommand.CommandTimeout = value; }
        }

        public static int SelectCommandTimeout {
            get { return SelectCommand.CommandTimeout; }
            set { SelectCommand.CommandTimeout = value; }
        }

        private static SqlCommand InsertCommand {
            get { return DataAdapter.InsertCommand; }
        }

        private static SqlCommand UpdateCommand {
            get { return DataAdapter.UpdateCommand; }
        }

        private static SqlCommand DeleteCommand {
            get { return DataAdapter.DeleteCommand; }
        }

        private static SqlCommand SelectCommand {
            get { return CommandCollection[0]; }
        }

        private static SqlDataAdapter DataAdapter {
            get { return GetPropertyValue("Adapter") as SqlDataAdapter; }
        }

        private static SqlCommand[] CommandCollection {
            get { return GetPropertyValue("CommandCollection") as SqlCommand[]; }
        }

        private static object GetPropertyValue(string propertyName) {
            return typeof(TableAdapter).GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.GetProperty | BindingFlags.Instance).GetValue(Adapter, null);
        }
    }
}

## How to use it.
TableAdapterAccessor<MyTableAdapter>.Adapter.ConnectionString = "...";                 // whatever...
TableAdapterAccessor<MyTableAdapter>.SelectCommandTimeout = 300;
TableAdapterAccessor<MyTableAdapter>.Adapter.Fill(...);

[C#] On Cache SQL Server Views

2008-07-02T16:55:24-07:00

This code seems to work pretty straight forward. I can't see an easy way to increase performace.

You could add an extra column to cCustomers and cPayments with a boolean value. This column would indicate if the row is dirty or not. A dirty row can mean two things:

* The row has been modified. Changes are not cached yet.
* The row has been added. Row is not cached yet.

You'll need a trigger or two in order to automatically update the value of this row. Then, whenever you cache the views, don't drop the cache tables, just update or add the dirty rows to the cache.

Bye.

[C#] On TableAdapter and CommandTimeout

2008-07-02T16:23:21-07:00

Thank you very much for your contribution. You made me check some advanced concepts on generics and reflection :D I find using reflection a bit like "hacking your own code", but it seems to be the only way to do a little of refactoring in this case. I've just adapted your solution to the philosophy behind the initial code (I hope you don't mind!).

namespace DataSetTableAdapters {

    partial class MyTableAdapter {
        public int InsertCommandTimeout {
            get { return TableAdapterAccessor<MyTableAdapter >.GetInsertCommand(this).CommandTimeout;  }
            set { TableAdapterAccessor<MyTableAdapter >.GetInsertCommand(this).CommandTimeout = value; }
        }

        public int UpdateCommandTimeout {
            get { return TableAdapterAccessor<MyTableAdapter >.GetUpdateCommand(this).CommandTimeout;  }
            set { TableAdapterAccessor<MyTableAdapter >.GetUpdateCommand(this).CommandTimeout = value; }
        }

        public int DeleteCommandTimeout {
            get { return TableAdapterAccessor<MyTableAdapter >.GetDeleteCommand(this).CommandTimeout;  }
            set { TableAdapterAccessor<MyTableAdapter >.GetDeleteCommand(this).CommandTimeout = value; }
        }

        public int SelectCommandTimeout {
            get { return TableAdapterAccessor<MyTableAdapter >.GetSelectCommand(this).CommandTimeout;  }
            set { TableAdapterAccessor<MyTableAdapter >.GetSelectCommand(this).CommandTimeout = value; }
        }
    }

    internal static class TableAdapterAccessor<TableAdapter> {

        public static global::System.Data.SqlClient.SqlCommand GetInsertCommand(TableAdapter tableAdapter) {
            return GetDataAdapter(tableAdapter).InsertCommand;
        }

        public static global::System.Data.SqlClient.SqlCommand GetUpdateCommand(TableAdapter tableAdapter) {
            return GetDataAdapter(tableAdapter).UpdateCommand; 
        }

        public static global::System.Data.SqlClient.SqlCommand GetDeleteCommand(TableAdapter tableAdapter) {
            return GetDataAdapter(tableAdapter).DeleteCommand; 
        }

        public static global::System.Data.SqlClient.SqlCommand GetSelectCommand(TableAdapter tableAdapter) {
            return GetCommandCollection(tableAdapter)[0];
        }

        private static global::System.Data.SqlClient.SqlDataAdapter GetDataAdapter(TableAdapter tableAdapter) {
            return typeof(TableAdapter).GetProperty("Adapter", global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.GetProperty | global::System.Reflection.BindingFlags.Instance).GetValue(tableAdapter, null) as global::System.Data.SqlClient.SqlDataAdapter;
        }

        private static global::System.Data.SqlClient.SqlCommand[] GetCommandCollection(TableAdapter tableAdapter) {
            return typeof(TableAdapter).GetProperty("CommandCollection", global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.GetProperty | global::System.Reflection.BindingFlags.Instance).GetValue(tableAdapter, null) as global::System.Data.SqlClient.SqlCommand[];
        }
    }
}

[C#] TableAdapter and CommandTimeout

2008-07-02T10:19:06-07:00

As TableAdapters are are automatically generated by DataSet editor, setting the CommandTimeout property for TableAdapter's internal commands is a common problem (see http://www.google.com/search?q=tableadapter+commandtimeout). The solution is a partial class of the TableAdapter that adds new functionality, just as the code below.

My problem with this is that it doesn't scale well. I have several TableAdapters in my DataSet, and I don't want to repeat this code for each of them. I've been thinking for a while but I haven't found a solution: the main problem to refactor this code is that the Adapter and CommandCollection properties are private.

Anybody has a good idea? If I find an elegant solution, I'll post it here.

Thanks.

namespace DataSetTableAdapters {

    partial class MyTableAdapter {

        public int InsertCommandTimeout {
            get { return (this.Adapter.InsertCommand.CommandTimeout); }
            set { this.Adapter.InsertCommand.CommandTimeout = value;  }
        }

        public int UpdateCommandTimeout {
            get { return (this.Adapter.UpdateCommand.CommandTimeout); }
            set { this.Adapter.UpdateCommand.CommandTimeout = value;  }
        }

        public int DeleteCommandTimeout {
            get { return (this.Adapter.DeleteCommand.CommandTimeout); }
            set { this.Adapter.DeleteCommand.CommandTimeout = value;  }
        }

        public int SelectCommandTimeout {
            get { return (this.CommandCollection[0].CommandTimeout); }

            set {
                for (int i = 0; (i < this.CommandCollection.Length); i = (i + 1)) {
                    if ((this.CommandCollection[i] != null)) {
                        ((global::System.Data.SqlClient.SqlCommand)(this.CommandCollection[i])).CommandTimeout = value;
                    }
                }
            }
        }
    }
}