我尝试将一堆数据插入数据库

insert_list = [(1,1,1),(2,2,2),(3,3,3),....] #up to 10000 tuples in this list

conn = pyodbc.connect('DRIVER={FreeTDS};SERVER=xxxxx;DATABASE=xxxx;UID=xx;PWD=xx;TDS_Version=7.0')
cursor = conn.cursor()

sql = "insert into ScanEMAxEMAHistoryDay(SecurityNumber,EMA1,EMA2,Crosstype,DayCross,IsLocalMinMax) values (?,?,?)"

cursor.executemany(sql,insert_list)

cursor.executemany(sql,insert_list)

pyodbc.ProgrammingError: (‘Invalid parameter type. param-index=4 param-type=numpy.int64’,‘HY105’)

减少到100元组：

cursor.executemany(sql,insert_list[:100])

cursor.executemany(sql,insert_list[:100])

pyodbc.ProgrammingError: (‘Invalid parameter type. param-index=4 param-type=numpy.int64’,‘HY105’)
cursor.executemany(sql,insert_list[:100])

减少到5元组：

cursor.executemany(sql,insert_list[:5])
conn.commit()

这可以插入数据库

我试着：

sql = 'SET GLOBAL max_allowed_packet=50*1024*1024'
cursor.execute(sql)

在excutemany()之前,它有一个错误：

pyodbc.ProgrammingError: (‘42000′,“[42000] [FreeTDS][sql Server]’GLOBAL’ is not a recognized SET option. (195) (sqlExecDirectW)”)

我是怎么解决这个问题的

谢谢.

您的问题不在于数据量本身,而是您的某些元组包含numpy.int64值,这些值不能直接用作sql语句的参数值.例如,

a = numpy.array([10,11,12],dtype=numpy.int64)
params = (1,a[1],1)
crsr.execute(sql,params)

会扔

ProgrammingError: (‘Invalid parameter type. param-index=2 param-type=numpy.int64’,‘HY105’)

因为第三个参数值是numpy数组a中的numpy.int64元素.使用int()转换该值将避免此问题：

a = numpy.array([10,int(a[1]),params)

顺便说一句,原因

sql = 'SET GLOBAL max_allowed_packet=50*1024*1024'
cursor.execute(sql)

没有用的是max_allowed_pa​​cket是MysqL设置,对Microsoft sql Server没有任何意义.

为什么以下失败/“从’Int64’到’DateTime’的无效转换.”例外？

long oldDate=new DateTime(2015,1,1).Ticks;
DateTime newDate=Convert.ToDateTime(oldDate);

.Ticks是long / Int64,Convert.ToDateTime(Int64)MSDN文档显示接受long / Int64的方法.

public static DateTime ToDateTime(
  long value
)

编辑：
如下面的ebyrob所指出的那样应该是：

long oldDate=new DateTime(2015,1).Ticks;
DateTime newDate=new DateTime(oldDate);

从Convert.ToDateTime方法(Int64)上的MSDN文档：

Calling this method always throws InvalidCastException.

和

Return Value
Type: System.DateTime
This conversion is not supported. No value is returned.

我不确定为什么不支持这一点,特别是如果新的DateTime(oldDate)运行良好：

DateTime newDate = new DateTime(oldDate);

我将创建一个必须是原子的“long”(Int64)代理,因此它在并发应用程序中的副本本质上是安全的.我不能使用Int32,因为它的范围太短.

我知道,只要涉及的数据可以适合双字(32位),原子性就应该得到保证.无论操作系统是32位还是64位.

现在,考虑以下“长”代理人……

注意：我省略了几种方法,因为我不需要它们.在这种情况下,我只需要基本转换为/从真正的长.

public struct SafeLong
    : IConvertible
{
    public SafeLong(long value)
    {
        unchecked
        {
            var arg = (ulong)value;
            this._data = new byte[]
            {
                (byte)arg,(byte)(arg >> 8),(byte)(arg >> 16),(byte)(arg >> 24),(byte)(arg >> 32),(byte)(arg >> 40),(byte)(arg >> 48),(byte)(arg >> 56),};
        }
    }



    private byte[] _data;



    private long Value
    {
        get
        {
            unchecked
            {
                var lo =
                    this._data[0] |
                    this._data[1] << 8 |
                    this._data[2] << 16 |
                    this._data[3] << 24;

                var hi = 
                    this._data[4] |
                    this._data[5] << 8 |
                    this._data[6] << 16 |
                    this._data[7] << 24;

                return (long)((uint)lo | (ulong)(uint)hi << 32);
            }
        }
    }



    public static implicit operator long(SafeLong value)
    {
        return value.Value;  // implicit conversion
    }



    public static explicit operator SafeLong(long value)
    {
        return new SafeLong(value);  // explicit conversion
    }


    #region IConvertible implementation

    public TypeCode GetTypeCode()
    {
        return Type.GetTypeCode(typeof(SafeLong));
    }

    public object ToType(Type conversionType,IFormatProvider provider)
    {
        return Convert.ChangeType(this.Value,conversionType);
    }

    public long ToInt64(IFormatProvider provider)
    {
        return this.Value;
    }

    // ... OMISSIS (not implemented) ...

    #endregion
}

好吧,它看起来像我期望的那样完美.

这是一个小测试：

class Program
{
    static void Main(string[] args)
    {
        var sla = (SafeLong)12345678987654321L;
        var la = (long)sla;
        Console.WriteLine(la);

        var slb = (SafeLong)(-998877665544332211L);
        var lb = (long)slb;
        Console.WriteLine(lb);

        Console.WriteLine(Marshal.SizeOf(typeof(SafeLong)));
        Console.WriteLine(Marshal.SizeOf(sla));
        Console.WriteLine(Marshal.SizeOf(slb));

        long lc = new SafeLong(556677);
        var slc = slb;
        Console.WriteLine(slc);
        slc = (SafeLong)lc;
        Console.WriteLine(slc);
        Console.WriteLine(slb);

        Console.Write("Press any key...");
        Console.ReadKey();
    }
}

SizeOf函数总是产生4个字节作为我的代理的大小.这个值是否保证了SafeLong-to-SafeLong副本的原子性,或者4个字节应该被解释为“真正的物理双字”？

无论长< - >的非原子性如何. SafeLong：它将被包含在安全的上下文中.

非常感谢提前.

你是对的,这是原子的,但圣洁的善良对于一个简单的问题来说这是一个复杂的解决方案.如果你想要一个长度值但使用引用为原子的结构,只需填充长！事实上,如果你这样做,那么你可以制作任何结构类型的原子版本,所以让我们这样做：

public struct SafeThing<T> where T : struct
{
    private object BoxedThing;

    public SafeThing(T value)
    {
        BoxedThing = value;
    }

    public T Value { get { return BoxedThing == null ? default(T) : (T)BoxedThing; } }

    public static implicit operator T(SafeThing<T> value)
    {
        return value.Value; 
    }

    public static implicit operator SafeThing<T>(T value)
    {
        return new SafeThing(value); 
    }
}

而且你已经完成了.你为什么要用阵列搞乱这一切？

另外,我注意到在您的实现中,您已经向后转换了显式/隐式转换.如果转换无损且不抛出,则只应隐式转换.您从SafeLong到long的隐式转换可以抛出,因此它不应该是隐式的.你从long到SafeLong的显式转换不能抛出并且是无损的,所以如果你想要的话它可能是隐含的.正如你所看到的,我已经通过使两个方向无损且无投掷来解决我的实现中的问题,因此它们都是隐含的.

请注意,此结构本质上是一个围绕盒装值的强类型包装器;如果在CLR的第一个版本中可以使用泛型类型,毫无疑问,盒装值类型将使用某种类型的类型实现,就像可空值类型类似地通过特殊泛型类型实现一样.

The SizeOf function yields always 4 bytes as the size of my surrogate. Does this value guarantees the atomicity of a copy SafeLong-to-SafeLong?

嗯,是的,不.

首先,“SizeOf”方法不会在内存中给出结构的大小;它在跨越托管/非托管边界持久化时给出结构的大小.这不一定与托管内存中结构的大小相同;它通常是相同的,但不保证是相同的.如果您想知道托管内存中结构的大小,则需要打开“不安全”模式并使用“sizeof”运算符.

实际上,大小为4的结构的副本总是原子的,只要它被复制到四字节边界上对齐的位置即可.语言规范并不保证任何四字节结构将以原子方式复制,但实际上在我们的实现中也是如此.

在您的特定情况下,这四个字节是对数组的引用;语言规范确保始终以原子方式复制引用.